/**
 * 购物车云同步工具
 * 实现购物车数据的云端存储和多设备同步
 */

const api = require('./api')
const request = require('./request')

class CartSync {
  constructor() {
    this.syncEnabled = false
    this.syncInterval = null
    this.lastSyncTime = 0
    this.syncDelay = 3000 // 延迟3秒同步，避免频繁API调用
    this.pendingSync = false
    this.syncQueue = []
  }

  /**
   * 初始化购物车同步
   */
  init(userId) {
    this.userId = userId
    
    if (userId && !this.syncEnabled) {
      console.log('[CartSync] 初始化购物车同步，用户ID:', userId)
      this.syncEnabled = true
      this.startAutoSync()
    }
    
    return this
  }

  /**
   * 启用自动同步
   */
  startAutoSync() {
    if (this.syncInterval) {
      clearInterval(this.syncInterval)
    }
    
    // 每30秒检查一次是否需要同步
    this.syncInterval = setInterval(() => {
      if (this.pendingSync && Date.now() - this.lastSyncTime > this.syncDelay) {
        this.syncToCloud()
      }
    }, 30000)
    
    console.log('[CartSync] 启动自动同步')
  }

  /**
   * 停止自动同步
   */
  stopAutoSync() {
    if (this.syncInterval) {
      clearInterval(this.syncInterval)
      this.syncInterval = null
    }
    
    this.syncEnabled = false
    console.log('[CartSync] 停止自动同步')
  }

  /**
   * 同步本地购物车到云端
   */
  syncToCloud() {
    if (!this.syncEnabled || !this.userId) {
      console.log('[CartSync] 同步未启用或用户未登录')
      return Promise.resolve(false)
    }
    
    const app = getApp()
    const cart = app.globalData.cart || []
    
    this.pendingSync = false
    this.lastSyncTime = Date.now()
    
    console.log('[CartSync] 同步购物车到云端:', cart.length, '个商品')
    
    // 构建同步数据
    const syncData = {
      userId: this.userId,
      cartItems: cart,
      deviceId: this.getDeviceId(),
      timestamp: Date.now()
    }
    
    // 请求API
    return request.post('/cart/sync', syncData, {
      loading: false,
      // 模拟数据
      mock: { success: true, message: '同步成功' },
      // 允许失败时降级到模拟数据
      fallbackToMock: true
    })
    .then(res => {
      console.log('[CartSync] 同步成功:', res)
      return true
    })
    .catch(err => {
      console.error('[CartSync] 同步失败:', err)
      // 同步失败时，将请求加入队列，稍后重试
      this.pendingSync = true
      return false
    })
  }

  /**
   * 从云端获取购物车数据
   */
  fetchFromCloud() {
    if (!this.syncEnabled || !this.userId) {
      console.log('[CartSync] 同步未启用或用户未登录')
      return Promise.resolve(null)
    }
    
    console.log('[CartSync] 从云端获取购物车数据')
    
    return request.get('/cart/fetch', { 
      userId: this.userId,
      deviceId: this.getDeviceId()
    }, {
      // 模拟数据
      mock: { 
        cartItems: [],
        timestamp: Date.now(),
        deviceId: this.getDeviceId()
      }
    })
    .then(res => {
      if (res.code === 200 && res.data) {
        console.log('[CartSync] 获取成功:', res.data)
        return res.data
      }
      return null
    })
    .catch(err => {
      console.error('[CartSync] 获取失败:', err)
      return null
    })
  }

  /**
   * 合并本地和云端购物车
   * 策略：
   * 1. 如果商品在本地和云端都存在，保留数量较大的
   * 2. 如果商品只在一方存在，保留存在的
   */
  async mergeCart() {
    if (!this.syncEnabled || !this.userId) {
      return false
    }
    
    const app = getApp()
    const localCart = app.globalData.cart || []
    
    try {
      // 获取云端购物车
      const cloudData = await this.fetchFromCloud()
      
      if (!cloudData || !cloudData.cartItems) {
        return false
      }
      
      const cloudCart = cloudData.cartItems
      
      // 如果云端购物车为空，且本地有数据，则直接上传本地数据
      if (cloudCart.length === 0 && localCart.length > 0) {
        this.syncToCloud()
        return true
      }
      
      // 如果本地购物车为空，直接使用云端数据
      if (localCart.length === 0 && cloudCart.length > 0) {
        app.globalData.cart = cloudCart
        wx.setStorageSync('cart', cloudCart)
        return true
      }
      
      // 合并购物车
      const mergedCart = []
      const productMap = {}
      
      // 先处理本地购物车
      localCart.forEach(item => {
        const key = `${item.productId}-${item.storeId}`
        productMap[key] = {
          ...item,
          quantity: item.quantity
        }
      })
      
      // 再处理云端购物车
      cloudCart.forEach(item => {
        const key = `${item.productId}-${item.storeId}`
        if (productMap[key]) {
          // 如果商品在本地和云端都存在，保留数量较大的
          productMap[key].quantity = Math.max(productMap[key].quantity, item.quantity)
        } else {
          // 如果商品只在云端存在，添加到合并结果
          productMap[key] = { ...item }
        }
      })
      
      // 转换为数组
      for (const key in productMap) {
        mergedCart.push(productMap[key])
      }
      
      // 更新本地购物车
      app.globalData.cart = mergedCart
      wx.setStorageSync('cart', mergedCart)
      
      // 合并后再同步到云端
      this.syncToCloud()
      
      console.log('[CartSync] 购物车合并完成，合并后商品数:', mergedCart.length)
      return true
      
    } catch (err) {
      console.error('[CartSync] 合并购物车失败:', err)
      return false
    }
  }

  /**
   * 标记需要同步
   */
  markForSync() {
    if (!this.syncEnabled) return
    
    this.pendingSync = true
    
    // 延迟同步，避免频繁API调用
    setTimeout(() => {
      if (this.pendingSync && Date.now() - this.lastSyncTime > this.syncDelay) {
        this.syncToCloud()
      }
    }, this.syncDelay)
  }

  /**
   * 获取设备标识
   */
  getDeviceId() {
    let deviceId = wx.getStorageSync('deviceId')
    
    if (!deviceId) {
      deviceId = 'wx_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)
      wx.setStorageSync('deviceId', deviceId)
    }
    
    return deviceId
  }

  /**
   * 清空购物车
   */
  clearCart() {
    if (!this.syncEnabled || !this.userId) return Promise.resolve(false)
    
    return request.delete('/cart/clear', { 
      userId: this.userId
    }, {
      // 模拟数据
      mock: { success: true, message: '清空成功' }
    })
    .then(res => {
      console.log('[CartSync] 清空购物车成功')
      return true
    })
    .catch(err => {
      console.error('[CartSync] 清空购物车失败:', err)
      return false
    })
  }
}

// 创建单例
const cartSync = new CartSync()

module.exports = cartSync 